home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 201-225 / disk_223 / csh / comm3.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  10KB  |  563 lines
  1. /*
  2.  * COMM3.C
  3.  *
  4.  * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  5.  *
  6.  */
  7.  
  8. do_assign() {
  9. switch(ac) {
  10.     case 1:  assignlist();
  11.          break;
  12.     case 2:  doassign(av[1], NULL);
  13.          break;
  14.     case 3:  doassign(av[1], av[2]);
  15.          break;
  16.     default: ierror(NULL, 500);
  17.          break;
  18.     }
  19. return 0;
  20. }
  21.  
  22. char *assign_errors[4]={
  23.     "",
  24.     "Name %s is not valid\n",
  25.     "Weird error\n",
  26.     "Can't cancel %s\n"
  27.     };
  28.  
  29. doassign(log, phy)
  30. char *log, *phy;
  31. {
  32. int last=strlen(log) - 1;
  33.  
  34. if (log[last] != ':') fprintf(stderr, "Bad name %s\n", log);
  35. else {
  36.     log[last] = 0;
  37.     fprintf(stderr,assign_errors[Assign(log, phy)],log);
  38.     }
  39. }
  40.  
  41. assignlist()
  42. {
  43. struct DirectoryEntry *de_head=NULL, *de;
  44. char buf[256];
  45. BPTR lock;
  46. int ctr=0;
  47.  
  48. AddDADevs(&de_head, DLF_DEVICES | DLF_VOLUMES | DLF_DIRS);
  49. printf("Devices:\n");
  50. for (de=de_head; de && de->de_Type==DLX_DEVICE; de=de->de_Next) {
  51.     printf("%-8s",de->de_Name);
  52.     if (ctr++ == 5) { ctr=0; printf("\n"); }
  53.     }
  54. printf("\n\nVolumes:\n");
  55. for (    ;
  56.     de && (de->de_Type==DLX_VOLUME || de->de_Type==DLX_UNMOUNTED);
  57.     de=de->de_Next
  58.     )
  59.     printf( "%-16s %s\n",
  60.         de->de_Name,
  61.         de->de_Type == DLX_VOLUME ? "[Mounted]" : ""
  62.         );
  63. printf("\nDirectories:\n");
  64. for (; de && de->de_Type==DLX_ASSIGN; de=de->de_Next) {
  65.     if (lock=Lock(de->de_Name, ACCESS_READ)) {
  66.         PathName(lock, buf, 256L);
  67.         UnLock(lock);
  68.         }
  69.     else
  70.         strcpy(buf,"Unexisting lock");
  71.     printf("%-20s%s\n",de->de_Name,buf);
  72.     }
  73. FreeDAList(&de_head);
  74. }
  75.  
  76. do_join()
  77. {
  78. BPTR sou, dest;
  79. char *buffer;
  80. unsigned int i;
  81. long n;
  82. char *namedest=av[--ac];
  83.  
  84. get_opt("r", &i);
  85. if (options==0 && exists(namedest)) { ierror(namedest,203); return 20; }
  86. if ( (buffer=malloc(8192)) == NULL ) { ierror(NULL,103); return 20; }
  87. if ( (dest=Open(namedest, MODE_NEWFILE)) == NULL )
  88.     { pError(namedest); goto fail1; }
  89. for (i=1; i<ac; i++) {
  90.     if ( (sou=Open(av[i], MODE_OLDFILE)) == NULL ) pError(av[i]);
  91.     else
  92.         while( (n=Read(sou, buffer, 8192L)) > 0 )
  93.             if (Write(dest, buffer, n) != n)
  94.                 { pError(namedest); Close(sou); goto fail2; }
  95.     Close(sou);
  96.     }
  97. fail2:
  98.     Close(dest);
  99. fail1:
  100.     free(buffer);
  101.     return 0;
  102. }
  103.  
  104. #define BUFDIM 512L
  105. #define MAXSTR 256
  106.  
  107. int minstr;
  108.  
  109. strings_in_file(s)
  110. char *s;
  111. {
  112. char c;
  113. char readbuf[BUFDIM+1], strbuf[MAXSTR+1];
  114. register unsigned int i, strctr=0;
  115. BPTR fh;
  116. int out, n;
  117.  
  118. if ( fh=Open(s, MODE_OLDFILE) ) {
  119.     fprintf(stderr, "Strings in %s (len>=%d):\n",s,minstr);
  120.     while ( (n=(int)Read(fh, readbuf, BUFDIM)) > 0 && !CHECKBREAK() )
  121.         for (i=0; i<n; i++) {
  122.         c=readbuf[i];
  123.         if (c<0x20 || c>0x7f) {
  124.             out=(strctr>=minstr);
  125.             if (!out) strctr=0;
  126.             }
  127.         else {
  128.             strbuf[strctr++]=c;
  129.             out=(strctr>=BUFDIM);
  130.             }
  131.         if (out) {
  132.             strbuf[strctr]='\0';
  133.             puts(strbuf);
  134.             strctr=0;
  135.             }
  136.         }
  137.     Close(fh);
  138.     }
  139. else pError(s);
  140. }
  141.  
  142. do_strings()
  143. {
  144. minstr=myatoi(av[--ac],1,255);
  145. all_args("r", strings_in_file, 0);
  146. return 0;
  147. }
  148.  
  149. BPTR myfile[MAXMYFILES];
  150.  
  151. do_open()
  152. {
  153. long mode;
  154. unsigned int n;
  155.  
  156. switch (av[2][0]) {
  157.     case 'r': mode=MODE_OLDFILE; break;
  158.     case 'w': mode=MODE_NEWFILE; break;
  159.     default : ierror(NULL,500); return;
  160.     }
  161. Errno=0;
  162. n=(unsigned int)myatoi(av[3],0,MAXMYFILES); if (Errno) return 20;
  163. myfile[n]=Open(av[1],mode);
  164. return (myfile[n]==NULL);
  165. }
  166.  
  167. do_close()
  168. {
  169. register unsigned int i;
  170. int n;
  171.  
  172. for (i=1; i<ac; i++) {
  173.     Errno=0;
  174.     n=myatoi(av[i],0,MAXMYFILES); if (Errno) return 20;
  175.     myclose(n);
  176.     }
  177. return 0;
  178. }
  179.  
  180. myclose(n)
  181. {
  182. if (myfile[n]) { Close(myfile[n]); myfile[n]=NULL; }
  183. }
  184.  
  185. do_fileslist()
  186. {
  187. register unsigned short i;
  188. int flag=0;
  189.  
  190. printf("Open files:");
  191. for (i=0; i<MAXMYFILES; i++)
  192.     if (myfile[i]) { printf(" %d",i); flag=1; }
  193. if (!flag) printf(" None!");
  194. printf("\n");
  195. return 0;
  196. }
  197.  
  198. BPTR extOpen(name,mode)
  199. char *name;
  200. long mode;
  201. {
  202. if (name[0]=='.') return myfile[atoi(name+1)];
  203. return Open(name,mode);
  204. }
  205.  
  206. extClose(fh)
  207. BPTR fh;
  208. {
  209. register unsigned short i;
  210.  
  211. for (i=0; i<MAXMYFILES; i++)
  212.     if (myfile[i]==fh) return;
  213. Close(fh);
  214. }
  215.  
  216. do_resident(avline)
  217. char *avline;
  218. {
  219. unsigned int i;
  220. BPTR seg;
  221. struct ResidentPrgNode *p;
  222.  
  223. get_opt("ar", &i);
  224. switch (options) {
  225.     case 0:
  226.     ObtainSemaphore (& (ArpBase->ResPrgProtection) );
  227.     if (p=ArpBase->ResidentPrgList) {
  228.         printf("Name             Users\n");
  229.         for (; p; p=p->rpn_Next)
  230.             printf("%-16s %-3ld\n",p->rpn_Name,p->rpn_Usage);
  231.         }
  232.     else printf("No resident program(s)\n");
  233.     ReleaseSemaphore(& (ArpBase->ResPrgProtection) );
  234.     break;
  235.     case 1:
  236.     for (; i<ac; i++)
  237.         if ( (seg=(BPTR)LoadPrg(av[i])) && AddResidentPrg(seg,av[i]) )
  238.             printf("OK! %s is now resident\n", BaseName(av[i]));
  239.         else pError(av[i]);
  240.     break;
  241.     case 2:
  242.     for (; i<ac; i++)
  243.         if (RemResidentPrg(av[i])) ierror(av[i],202);
  244.         else printf("Removed %s\n",av[i]);
  245.     break;
  246.     default:
  247.     ierror(NULL,500);
  248.     break;
  249.     }
  250. return 0;
  251. }
  252.  
  253. struct ProcessControlBlock pcb={
  254.     4000,        /* pcb_StackSize    */
  255.     0,        /* pcb_Pri        */
  256.     };
  257. /* remaining field are NULL */
  258.     
  259. do_truerun(avline, backflag)
  260. char *avline;
  261. {
  262. char name[200];
  263. char *FindIt();
  264.  
  265. if (backflag) {
  266.     pcb.pcb_Control=NULL;
  267.     pcb.pcb_Input=pcb.p_Output=Open("NIL:",MODE_OLDFILE);
  268.     }
  269. else {
  270.     pcb.pcb_Control=NULL;
  271.     pcb.pcb_Input=pcb.p_Output =NULL;
  272.     }
  273. if (FindIt(av[1], "", name))
  274.     ASyncRun(name,next_word(next_word(avline)),&pcb);
  275. else
  276.     ierror(av[1],205);
  277. return 0;
  278. }
  279.  
  280. int exists(name)
  281. char *name;
  282. {
  283. BPTR lock;
  284.  
  285. if (lock=Lock(name,ACCESS_READ)) {
  286.     UnLock(lock);
  287.     return 1;
  288.     }
  289. return 0;
  290. }
  291.  
  292. do_aset()
  293. {
  294. Setenv(av[1],av[2]);
  295. return 0;
  296. }
  297.  
  298. #define HTYPELINE 16L
  299.  
  300. htype_a_file(s)
  301. char *s;
  302. {
  303. BPTR fh;
  304. long n, filesize=0;
  305. char buf[HTYPELINE+1];
  306. register unsigned int i;
  307.  
  308. if ( (fh=Open(s,MODE_OLDFILE))==NULL ) { pError(s); return 20; }
  309. while ( (n=Read(fh,buf,HTYPELINE))>0 && !dobreak()) {
  310.     printf("%06lx: ",filesize);
  311.     filesize+=n;
  312.     for (i=0; i<n; i++) {
  313.         printf( (i&3) ? "%02x" : " %02x",(int)(unsigned char)buf[i]);
  314.         if (buf[i]<=0x20) buf[i]='.';
  315.         }
  316.     for ( ; i<HTYPELINE; i++) {
  317.         printf( (i&3) ? "  " : "   ");
  318.         buf[i]=' ';
  319.         }
  320.     buf[i]=0;
  321.     printf("    %s\n",buf);
  322.     }
  323. Close(fh);
  324. return 0;
  325. }
  326.  
  327. do_htype()
  328. {
  329. all_args("", htype_a_file, 0);
  330. return 0;
  331. }
  332.  
  333. do_stack()
  334. {
  335. long n;
  336.  
  337. if (ac>1) {
  338.     Errno=0;
  339.     n=Atol(av[1]);
  340.     if (!Errno) Mycli->cli_DefaultStack=(long)(n >> 2L);
  341.     }
  342. else printf("current stack size is %ld bytes\n",
  343.                 (long)Mycli->cli_DefaultStack << 2L);
  344. return 0;
  345. }
  346.  
  347. do_fault()
  348. {
  349. struct PERROR *p;
  350. register unsigned int i;
  351. int n;
  352.  
  353. for (i=1; i<ac; i++) {
  354.     n=myatoi(av[i],0,32767);
  355.     if (!Errno) {
  356.         for (p=Perror; p->errnum && p->errnum!=n; p++);
  357.         if (p->errnum)
  358.             printf("Fault %d: %s\n",n,p->errstr);
  359.         else
  360.             printf("Fault %d not recognized\n",n);
  361.         }
  362.     }
  363. return 0;
  364. }
  365.  
  366. struct rpncommand {
  367.     char *str;
  368.     int parsin, parsout;
  369.     };
  370.  
  371. struct rpncommand rpn[]={
  372.     "+",    2,    1,
  373.     "-",    2,    1,
  374.     "*",    2,    1,
  375.     "/",    2,    1,
  376.     "%",    2,    1,
  377.     "&",    2,    1,
  378.     "|",    2,    1,
  379.     "~",    1,    1,
  380.     ">",    2,    1,
  381.     "<",    2,    1,
  382.     "==",    2,    1,
  383.     "!",    1,    1,
  384.     "DUP",    1,    2,
  385.     "DROP",    1,    0,
  386.     "SWAP",    2,    2,
  387.     "HELP",    0,    0,
  388.     NULL,    0,    1,    /* this looks for a number */
  389. };
  390.  
  391. do_rpn(garbage,ifflag) /* ifflag!=0 if called from if */
  392. char *garbage;
  393. {
  394. register long n0, n1;
  395. long t;
  396. unsigned int i, j;
  397. int sp=0;
  398. long stack[100];
  399. struct rpncommand *temp;
  400.  
  401. i=1;
  402. if (ifflag) get_opt("rn",&i);
  403. for (; i<ac; i++) {
  404.     for (j=0; rpn[j].str && Strcmp(rpn[j].str,av[i]); j++) ;
  405.     n0=stack[sp-1];
  406.     n1=stack[sp-2];
  407.     sp -= (rpn[j].parsin);
  408.     if (sp<0) { fprintf(stderr, "RPN: Empty stack\n"); return 1; }
  409.     switch (j) {
  410.       case 0:    n0 += n1;        break;
  411.       case 1:    n0 = n1-n0;        break;
  412.       case 2:    n0 *= n1;        break;
  413.       case 3:    n0 = n1/n0;        break;
  414.       case 4:    n0 = n1%n0;        break;
  415.       case 5:    n0 &= n1;        break;
  416.       case 6:    n0 |= n1;        break;
  417.       case 7:    n0 =  ~n0;        break;
  418.       case 8:    n0 = (n1 > n0);        break;
  419.       case 9:    n0 = (n1 < n0);        break;
  420.       case 10:    n0 = (n0 == n1);    break;
  421.       case 11:    n0 = !n0;        break;
  422.       case 12:    n1=n0;            break;
  423.       case 13:    t=n0; n0=n1; n1=t;    break;
  424.       case 14:                break;
  425.       case 15:    printf("In Commands Out\n");
  426.             for (temp=rpn; temp->str; temp++)
  427.                 printf(" %d %-10s%d\n",
  428.                 temp->parsin,temp->str,temp->parsout);
  429.             break;
  430.       default:    Errno=0;
  431.             n0=Atol(av[i]);
  432.             if (Errno) {
  433.                 fprintf(stderr, "Bad RPN cmd: %s\n",av[i]);
  434.                 return 20;
  435.                 }
  436.             break;
  437.       }
  438.     stack[sp]=n0;
  439.     stack[sp+1]=n1;
  440.     sp += rpn[j].parsout;
  441.     }
  442. if (ifflag) return (int)(stack[sp-1]);    /* called from if: return top value */
  443. for (i=sp-1;(int)i>=0;i--) printf("%ld\n", stack[i]); /* else print stack */
  444. return 0;
  445. }
  446.  
  447. do_path()
  448. {
  449. union {    long *lp; long ll; } l;
  450. char buf[256];
  451.  
  452. puts("Current dir");
  453. l.lp = (long *) Mycli->cli_CommandDir;
  454. while (l.ll) {
  455.     l.ll <<= 2;
  456.     PathName(l.lp[1], buf, 256L);
  457.     puts(buf);
  458.     l.ll = *l.lp;
  459.     }
  460. puts("C:");
  461. return 0;
  462. }
  463.  
  464. do_pri()
  465. {
  466. int t, pri;
  467. struct Process *proc;
  468.  
  469. t=myatoi(av[1],0,20); if (Errno) return 20;
  470. pri=myatoi(av[2],-128,127); if (Errno) return 20;
  471. Forbid();
  472. proc=(t==0 ? Myprocess : FindCLI((long)t));
  473. if (proc==NULL) fprintf(stderr, "process not found\n");
  474.     else SetTaskPri(proc, (long)pri);
  475. Permit();
  476. return 0;
  477. }
  478.  
  479. do_strleft()
  480. {
  481. char buf[256];
  482. int n;
  483.  
  484. strcpy(buf,av[2]);
  485. n=myatoi(av[3],1,strlen(buf)); if (Errno) return 20;
  486. buf[n]='\0';
  487. set_var(LEVEL_SET, av[1], buf);
  488. return 0;
  489. }
  490.  
  491. do_strright()
  492. {
  493. char buf[256];
  494. int n;
  495.  
  496. strcpy(buf, av[2]);
  497. n=myatoi(av[3],1,strlen(buf)); if (Errno) return 20;
  498. set_var(LEVEL_SET, av[1], buf+strlen(buf)-n);
  499. return 0;
  500. }
  501.  
  502. do_strmid()
  503. {
  504. char buf[256];
  505. int n1, n2;
  506.  
  507. strcpy(buf, av[2]);
  508. n1=myatoi(av[3],1,strlen(buf))-1; if (Errno) return 20;
  509. if (ac>4) {
  510.     n2=myatoi(av[4],1,strlen(buf)-n1);
  511.     if (Errno) return 20;
  512.     buf[n1+n2]='\0';
  513.     }
  514. set_var(LEVEL_SET, av[1], buf+n1);
  515. return 0;
  516. }
  517.  
  518. do_strlen()
  519. {
  520. char buf[16];
  521.  
  522. sprintf(buf,"%d",strlen(av[2]));
  523. set_var(LEVEL_SET, av[1], buf);
  524. return 0;
  525. }
  526.  
  527. myatoi(s,min,max)
  528. char *s;
  529. {
  530. long n;
  531.  
  532. Errno=0;
  533. n=Atol(s);
  534. if (Errno==ERRBADINT) ierror(s,511);
  535.     else if (n<min || n>max) {
  536.         Errno=ERRBADINT;
  537.         printf("%s not in (%d,%d)\n",s,min,max);
  538.         }
  539. return (int)n;
  540. }
  541.  
  542. do_fltlower()
  543. {
  544. char buf[256], *s;
  545.  
  546. while (!CHECKBREAK() && gets(buf)) {
  547.     for (s=buf; *s; s++) *s=tolower(*s);
  548.     puts(buf);
  549.     }
  550. return 0;
  551. }
  552.  
  553. do_fltupper()
  554. {
  555. char buf[256], *s;
  556.  
  557. while (!CHECKBREAK() && gets(buf)) {
  558.     for (s=buf; *s; s++) *s=toupper(*s);
  559.     puts(buf);
  560.     }
  561. return 0;
  562. }
  563.